{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ebd66700",
   "metadata": {},
   "source": [
    "## Demo_Landscape\n",
    "This is a demo for visualizing the Landscape of a Neuron Network\n",
    "\n",
    "To run this demo from scratch, you need first generate a BadNet attack result by using the following cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b950f4fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "! python ../../attack/badnet.py --save_folder_name badnet_demo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f81f973",
   "metadata": {},
   "source": [
    "or run the following command in your terminal\n",
    "\n",
    "```python attack/badnet.py --save_folder_name badnet_demo```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5465b02c",
   "metadata": {},
   "source": [
    "**Remark**: **Message Passing Interface (MPI)** is needed to accelerate the computation of loss landscape. \n",
    "\n",
    "To install it, you can run the following commands in your terminal:\n",
    "\n",
    "```sudo apt install libopenmpi-dev```\n",
    "\n",
    "```pip install mpi4py```\n",
    "\n",
    "Finally, you need also clone the repo https://github.com/tomgoldstein/loss-landscape to the ***visualization*** folder.\n",
    "\n",
    "For more information, please refer to ***readme file***."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87bd9f5a",
   "metadata": {},
   "source": [
    "### Step 1: Import modules and set arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "71b7087b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/anaconda3/envs/py38/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: libc10_hip.so: cannot open shared object file: No such file or directory\n",
      "  warn(f\"Failed to load image Python extension: {e}\")\n"
     ]
    }
   ],
   "source": [
    "import sys, os\n",
    "import yaml\n",
    "import torch\n",
    "import numpy as np\n",
    "import torchvision.transforms as transforms\n",
    "import socket\n",
    "sys.path.append(\"../\")\n",
    "sys.path.append(\"../../\")\n",
    "sys.path.append(\"../loss-landscape\")\n",
    "sys.path.append(os.getcwd())\n",
    "from visual_utils import *\n",
    "from utils.aggregate_block.dataset_and_transform_generate import (\n",
    "    get_transform,\n",
    "    get_dataset_denormalization,\n",
    ")\n",
    "from utils.aggregate_block.fix_random import fix_random\n",
    "from utils.aggregate_block.model_trainer_generate import generate_cls_model\n",
    "from utils.save_load_attack import load_attack_result\n",
    "from utils.defense_utils.dbd.model.utils import (\n",
    "    get_network_dbd,\n",
    "    load_state,\n",
    "    get_criterion,\n",
    "    get_optimizer,\n",
    "    get_scheduler,\n",
    ")\n",
    "from utils.defense_utils.dbd.model.model import SelfModel, LinearModel\n",
    "\n",
    "import projection as proj\n",
    "import net_plotter as net_plotter\n",
    "import plot_2D as plot_2D\n",
    "import plot_surface as plot_surface\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2fb719c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Basic setting: args\n",
    "args = get_args(True)\n",
    "\n",
    "########## For Demo Only ##########\n",
    "args.yaml_path = \"../../\"+args.yaml_path\n",
    "args.result_file_attack = \"badnet_demo\"\n",
    "######## End For Demo Only ##########\n",
    "\n",
    "with open(args.yaml_path, \"r\") as stream:\n",
    "    config = yaml.safe_load(stream)\n",
    "config.update({k: v for k, v in args.__dict__.items() if v is not None})\n",
    "args.__dict__ = config\n",
    "args = preprocess_args(args)\n",
    "fix_random(int(args.random_seed))\n",
    "\n",
    "save_path_attack = \"../..//record/\" + args.result_file_attack\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f959b510",
   "metadata": {},
   "source": [
    "### Step 2: Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b8b67ac9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:save_path MUST have 'record' in its abspath, and data_path in attack result MUST have 'data' in its path\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "loading...\n",
      "Create visualization dataset with \n",
      " \t Dataset: clean_train \n",
      " \t Number of samples: 50000  \n",
      " \t Selected classes: [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# Load result\n",
    "result_attack = load_attack_result(save_path_attack + \"/attack_result.pt\")\n",
    "selected_classes = np.arange(args.num_classes)\n",
    "\n",
    "# keep the same transforms for train and test dataset for better visualization\n",
    "result_attack[\"clean_train\"].wrap_img_transform = result_attack[\"clean_test\"].wrap_img_transform \n",
    "result_attack[\"bd_train\"].wrap_img_transform = result_attack[\"bd_test\"].wrap_img_transform \n",
    "\n",
    "# Create dataset\n",
    "args.visual_dataset = 'clean_train'\n",
    "if args.visual_dataset == 'clean_train':\n",
    "    visual_dataset = result_attack[\"clean_train\"]\n",
    "elif args.visual_dataset == 'bd_train':  \n",
    "    visual_dataset = result_attack[\"bd_train\"]\n",
    "    visual_dataset.getitem_all = False # only return img and label\n",
    "    \n",
    "else:\n",
    "    assert False, \"Illegal vis_class\"\n",
    "\n",
    "print(f'Create visualization dataset with \\n \\t Dataset: {args.visual_dataset} \\n \\t Number of samples: {len(visual_dataset)}  \\n \\t Selected classes: {selected_classes}')\n",
    "\n",
    "# Create data loader\n",
    "data_loader = torch.utils.data.DataLoader(\n",
    "    visual_dataset, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False\n",
    ")\n",
    "\n",
    "# Create denormalization function\n",
    "for trans_t in data_loader.dataset.wrap_img_transform.transforms:\n",
    "    if isinstance(trans_t, transforms.Normalize):\n",
    "        denormalizer = get_dataset_denormalization(trans_t)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f652e5",
   "metadata": {},
   "source": [
    "### Step 3: Load Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ff67e7b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load model preactresnet18 from badnet_demo\n"
     ]
    }
   ],
   "source": [
    "# Load model\n",
    "model_visual = generate_cls_model(args.model, args.num_classes)\n",
    "model_visual.load_state_dict(result_attack[\"model\"])\n",
    "model_visual\n",
    "# !!! Important to set eval mode !!!\n",
    "model_visual.eval()\n",
    "print(f\"Load model {args.model} from {args.result_file_attack}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc952077",
   "metadata": {},
   "source": [
    "### Step 4: Setup parameters for Loss Landscape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94612903",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank 0 use GPU 0 of 8 GPUs on ai07\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No protocol specified\n"
     ]
    }
   ],
   "source": [
    "import mpi4pytorch as mpi\n",
    "\n",
    "# Set range for landscape\n",
    "args.x = '-1:1:5'\n",
    "args.y = '-1:1:5'\n",
    "\n",
    "# Additional Agrs for Loss Landscape\n",
    "args.mpi=True\n",
    "args.cuda=True\n",
    "args.show = False\n",
    "args.model_file = save_path_attack\n",
    "args.model_file1 = \"\"\n",
    "args.model_fil2 = \"\"\n",
    "args.data_split = 0\n",
    "args.proj_file = \"\"\n",
    "\n",
    "#--------------------------------------------------------------------------\n",
    "# Environment setup\n",
    "#--------------------------------------------------------------------------\n",
    "\n",
    "if args.mpi:\n",
    "    comm = mpi.setup_MPI()\n",
    "    rank, nproc = comm.Get_rank(), comm.Get_size()\n",
    "else:\n",
    "    comm, rank, nproc = None, 0, 1\n",
    "\n",
    "# in case of multiple GPUs per node, set the GPU to use for each rank\n",
    "if args.cuda:\n",
    "    if not torch.cuda.is_available():\n",
    "        raise Exception('User selected cuda option, but cuda is not available on this machine')\n",
    "    gpu_count = torch.cuda.device_count()\n",
    "    torch.cuda.set_device(rank % gpu_count)\n",
    "    print('Rank %d use GPU %d of %d GPUs on %s' %\n",
    "          (rank, torch.cuda.current_device(), gpu_count, socket.gethostname()))\n",
    "    \n",
    "#--------------------------------------------------------------------------\n",
    "# Check plotting resolution\n",
    "#--------------------------------------------------------------------------\n",
    "try:\n",
    "    args.xmin, args.xmax, args.xnum = [float(a) for a in args.x.split(':')]\n",
    "    args.ymin, args.ymax, args.ynum = (None, None, None)\n",
    "    args.xnum = int(args.xnum)\n",
    "    if args.y:\n",
    "        args.ymin, args.ymax, args.ynum = [float(a) for a in args.y.split(':')]\n",
    "        assert args.ymin and args.ymax and args.ynum, \\\n",
    "        'You specified some arguments for the y axis, but not all'\n",
    "        args.ynum = int(args.ynum)\n",
    "except:\n",
    "    raise Exception('Improper format for x- or y-coordinates. Try something like -1:1:51')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b549f20",
   "metadata": {},
   "source": [
    "### Step 5: Setup directions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "543f9755",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------\n",
      "setup_direction\n",
      "-------------------------------------------------------------------\n",
      "../..//record/badnet_demo_weights_xignore=biasbn_xnorm=filter_yignore=biasbn_ynorm=filter.h5 is already setted up\n",
      "../..//record/badnet_demo_weights_xignore=biasbn_xnorm=filter_yignore=biasbn_ynorm=filter.h5_[-1.0,1.0,5]x[-1.0,1.0,5].h5 is already set up\n"
     ]
    }
   ],
   "source": [
    "#--------------------------------------------------------------------------\n",
    "# Extract model parameters\n",
    "#--------------------------------------------------------------------------\n",
    "w = net_plotter.get_weights(model_visual) # initial parameters\n",
    "s = copy.deepcopy(model_visual.state_dict()) # deepcopy since state_dict are references\n",
    "if args.ngpu > 1:\n",
    "    # data parallel with multiple GPUs on a single node\n",
    "    net = torch.nn.DataParallel(model_visual, device_ids=range(torch.cuda.device_count()))\n",
    "\n",
    "\n",
    "#--------------------------------------------------------------------------\n",
    "# Setup the direction file and the surface file\n",
    "#--------------------------------------------------------------------------\n",
    "dir_file = net_plotter.name_direction_file(args) # name the direction file\n",
    "if rank == 0:\n",
    "    net_plotter.setup_direction(args, dir_file, model_visual)\n",
    "\n",
    "surf_file = plot_surface.name_surface_file(args, dir_file)\n",
    "if rank == 0:\n",
    "    plot_surface.setup_surface_file(args, surf_file, dir_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "11402470",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cosine similarity between x-axis and y-axis: -0.000373\n"
     ]
    }
   ],
   "source": [
    "# load directions\n",
    "d = net_plotter.load_directions(dir_file)\n",
    "# calculate the consine similarity of the two directions\n",
    "if len(d) == 2 and rank == 0:\n",
    "    similarity = proj.cal_angle(proj.nplist_to_tensor(d[0]), proj.nplist_to_tensor(d[1]))\n",
    "    print('cosine similarity between x-axis and y-axis: %f' % similarity)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51109487",
   "metadata": {},
   "source": [
    "### Step 6: Computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5eb99a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing 0 values for rank 0\n",
      "Rank 0 done!  Total time: 0.00 Sync: 0.00\n"
     ]
    }
   ],
   "source": [
    "#--------------------------------------------------------------------------\n",
    "# Start the computation\n",
    "#--------------------------------------------------------------------------\n",
    "plot_surface.crunch(surf_file, model_visual, w, s, d, data_loader, 'train_loss', 'train_acc', comm, rank, args)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b94261",
   "metadata": {},
   "source": [
    "### Step 7: Show the Landscape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "65f7e8a9",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'z')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#--------------------------------------------------------------------------\n",
    "# Plot figures\n",
    "#--------------------------------------------------------------------------\n",
    "\n",
    "import h5py\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import cm\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "f = h5py.File(surf_file, 'r')\n",
    "x = np.array(f['xcoordinates'][:])\n",
    "y = np.array(f['ycoordinates'][:])\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "surf_name = \"train_loss\"\n",
    "\n",
    "if surf_name in f.keys():\n",
    "    Z = np.array(f[surf_name][:])\n",
    "elif surf_name == 'train_err' or surf_name == 'test_err' :\n",
    "    Z = 100 - np.array(f[surf_name][:])\n",
    "else:\n",
    "    print ('%s is not found in %s' % (surf_name, surf_file))\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "# Plot 3D surface\n",
    "# --------------------------\n",
    "fig = plt.figure()\n",
    "\n",
    "def Axes3D(fig):\n",
    "    return fig.add_subplot(projection='3d')\n",
    "ax = Axes3D(fig)\n",
    "surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
    "fig.colorbar(surf, shrink=0.5, aspect=5)\n",
    "\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_zlabel('z')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5aef284",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another way to show the results is the function provided by plot_2D\n",
    "if rank == 0:\n",
    "    args.vmin = 0.1 \n",
    "    args.vmax = 10 \n",
    "    args.vlevel = 0.5    \n",
    "    if args.y and args.proj_file:\n",
    "        plot_2D.plot_contour_trajectory(surf_file, dir_file, args.proj_file, 'train_loss', args.show)\n",
    "    elif args.y:\n",
    "        plot_2D.plot_2d_contour(surf_file, 'train_loss', args.vmin, args.vmax, args.vlevel, args.show)\n",
    "    else:\n",
    "        plot_1D.plot_1d_loss_err(surf_file, args.xmin, args.xmax, args.loss_max, args.log, args.show)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "6869619afde5ccaa692f7f4d174735a0f86b1f7ceee086952855511b0b6edec0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
